package com.neusoft.mid.msf.common.util;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;

import java.lang.reflect.*;

/**
 * @program: pangu
 * @description: 反射工具类, 提供调用 set/get方法,访问私有变量,调用私有方法,获取泛型Class,被aop过的真实类等工具函数
 * @author: fengjd
 * @create: 2022-07-25 15:31
 **/
public class ReflectionUtils {

    private static final String SETTER_PREFIX = "set";
    private static final String GETTER_PREFIX = "GET";
    private static final String CGLIB_CLASS_SEPARATOR = "$$";

    private static Logger logger = LoggerFactory.getLogger(ReflectionUtils.class);

    public static Object invokeGetter(Object obj, String propertyName) {
        Object object = obj;
        for (String name : StringUtils.split(propertyName, ".")) {
            String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
            object = invokeMethod(object, getterMethodName, new Class[]{}, new Object[]{});
        }

        return object;
    }

    /**
     * 调用setter方法, 仅匹配方法名
     * 支持多级,如: 对象名,方法
     *
     * @param obj
     * @param propertyName
     * @param value
     */
    public static void invokeSetter(Object obj, String propertyName, Object value) {
        Object object = obj;
        String[] names = StringUtils.split(propertyName, ".");
        for (int i = 0; i < names.length; i++) {
            if (i < names.length - 1) {
                String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
                 object = invokeMethod(object, getterMethodName, new Class[]{}, new Object[]{});
            } else {

            }
        }

    }

    /**
     * 直接读取对象属性值,无视private/protect修饰符,不经过getter函数
     * @param obj
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(final Object obj, final String fieldName){
        Field field = getAccessibleField(obj, fieldName);
        if (field == null) {
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] in object [" + obj+ "]");
        }
        Object result = null ;
        try {
          result = field.get(obj);
        } catch (IllegalAccessException e) {
            logger.error("不可能抛出的异常{} ",e.getMessage());
        }
        return result;
    }

    public static void setFieldValue(final Object obj, final String fieldName, final Object value){
        Field field = getAccessibleField(obj, fieldName);
        if (field==null) {
            logger.error("Could not find field [" + fieldName + "] in object ["+ obj+ "]");
            return;
        }
        try {
            field.set(obj,convert(value,field.getType()));
        } catch (IllegalAccessException e) {
            logger.error("不可能抛出的异常:{} ",e.getMessage());
        }

    }



    /**
     * 将obj转换成 type类型
     * @param obj
     * @param type
     * @return
     */
    public static Object convert(Object obj, Class<?> type) {
        if (obj instanceof Number) {
            Number number = (Number) obj;
            if (type.equals(byte.class) || type.equals(Byte.class)) {
                return number.byteValue();
            }
            if (type.equals(short.class) || type.equals(Short.class)) {
                return number.byteValue();
            }
            if (type.equals(int.class) || type.equals(Integer.class)) {
                return number.byteValue();
            }
            if (type.equals(long.class) || type.equals(Long.class)) {
                return number.byteValue();
            }
            if (type.equals(float.class) || type.equals(Float.class)) {
                return number.byteValue();
            }
            if (type.equals(double.class) || type.equals(Double.class)) {
                return number.byteValue();
            }

        }
        if (type.equals(String.class)) {
            return obj == null ? "" : obj.toString();
        }

        return obj;
    }

    public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes, final Object[] args) {

        Method method = getAccessibleMethod(obj, methodName, parameterTypes);
        if (method == null) {
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on [" + obj + "]");
        }

        try {
            return method.invoke(obj, args);
        } catch (Exception e) {
            throw convertReflectionException(e);
        }

    }

    public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
        Method method = getAccessibleMethodByName(obj, methodName);
        if (method == null) {
            throw new IllegalArgumentException("Could not find method [" + methodName + "]  on target [" + obj + "]");
        }

        try {
            return method.invoke(obj, args);
        } catch (Exception e) {
            throw convertReflectionException(e);
        }
    }

    public static Field getAccessibleField(final Object obj, final String fieldName) {
        Validate.notNull(obj, "object can't be null ");
        Validate.notBlank(fieldName, "fieldName name can't be blank'");
        for (Class<?> superClass = obj.getClass();superClass!=Object.class;superClass = superClass.getSuperclass()){
            try {
                Field field =superClass.getDeclaredField(fieldName);
                makeAccessible(field);
                return field;
            } catch (NoSuchFieldException e) {
                continue; //field不在当前类定义,继续向上定义
            }
        }

        return null;
    }




    /**
     * 将反射时的checked exception转换成unchecked exception
     *
     * @param e
     * @return
     */
    public static RuntimeException convertReflectionException(Exception e) {
        if ((e instanceof IllegalAccessException || e instanceof IllegalArgumentException || e instanceof NoSuchMethodException)) {
            return new IllegalArgumentException(e);
        } else if (e instanceof InvocationTargetException) {
            return new RuntimeException(((InvocationTargetException) e).getTargetException());
        } else if (e instanceof RuntimeException) {
            return (RuntimeException) e;
        }
        return new RuntimeException("unexpected Checked Exception.", e);
    }

    /**
     * 循环向上转型, 获取对象的DeclaredMethod,并轻质设置为可访问
     * 如向上转型到Object任无法找到,返回null
     * 匹配函数名+参数类型
     * <p>
     * 用于方法需要被多次调用的情况,先使用本函数先取得method,在调用method.invoke(obejct obj,object... args)
     */
    public static Method getAccessibleMethod(final Object obj, final String methodName, final Class<?>... parameterTypes) {
        Validate.notNull(obj, "object can't be null");
        Validate.notBlank(methodName, "method name can't be null");

        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {

            try {
                Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
                makeAccessible(method);
                return method;
            } catch (NoSuchMethodException e) {
                continue;
            }
        }
        return null;

    }

    public static Method getAccessibleMethodByName(final Object obj, final String methodName) {

        Validate.notNull(obj, "object can't be null");
        Validate.notBlank(methodName, "method name can't be blank");
        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
            Method[] methods = searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (method.getName().equals(methodName)) {
                    makeAccessible(method);
                    return method;
                }
            }
        }
        return null;
    }

    /**
     * 改变private/protected 的方法为public,尽量不调用实际改动的语句,避免JDK的
     */
    public static void makeAccessible(Method method) {
        boolean b = Modifier.isPublic(method.getModifiers()) || Modifier.isPublic(method.getDeclaringClass().getModifiers());
        if (!b && !method.isAccessible()) {
            method.setAccessible(true);
        }

    }

    /**
     * 改变private/protected的成员变量为public,尽量不调用实际改动的语句,避免jdk的securityManager报错
     * @param field
     */
    public static void makeAccessible(Field field){
        if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())|| Modifier.isFinal(field.getModifiers()))
                &&!field.isAccessible()) {
            field.setAccessible(true);
        }
    }


    /**
     * 通过反射,获得class定义中申明的泛型参数的类型,注意泛型必须定义在父类处
     * 如无法找到,返回object.class
     *
     * @param clazz
     * @return
     * @param <T>
     */
    public static <T> Class<T> getClassGenricType(final Class clazz){
        return getClassGenricType(clazz,0);
    }

    public static Class getClassGenricType(final Class clazz, final int index){

        Type genType = clazz.getGenericSuperclass();
        if (!(genType instanceof ParameterizedType)) {
            logger.warn(clazz.getSimpleName()+"s superClass not a ParameterizedType");
            return Object.class;
        }
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if ((index >= params.length || index < 0 )) {
            logger.warn("index: "+index+",Size of " +clazz.getSimpleName() + " 's parameterized Type: "+params.length);
            return Object.class;
        }

        if ((params[index] instanceof Class)) {
            logger.warn(clazz.getSimpleName() + "not set the actual class on superClass generic parameter");
            return Object.class;
        }

        return ((Class) params[index]);

    }

    public static Class<?> getUserClass(Object instance){
        Assert.notNull(instance, "instance must not be null");
        Class clazz = instance.getClass();
        if (clazz!= null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
            Class<?> superClass = clazz.getSuperclass();
            if (superClass != null && Object.class.equals(superClass)) {
                return superClass;
            }
        }
        return clazz;
    }
}
